home *** CD-ROM | disk | FTP | other *** search
/ 10,000 Great Games / 10,000 Great Games.iso / Product / 66 / data1.cab / Source_Files / Src / Char.cpp < prev    next >
C/C++ Source or Header  |  2000-01-16  |  18KB  |  898 lines
  1. #include "stdafx.h"
  2.  
  3. cCharacter::cCharacter(cProperties *_orig)
  4.         : cGameObject(_orig)
  5. {
  6.     // Get animations
  7.     
  8.     orig->get_sequence("WALK LEFT", walk_left_seq);
  9.     orig->get_sequence("WALK RIGHT", walk_right_seq);
  10.     orig->get_sequence("WALK LEFT RIGHT", walk_left_right_seq);
  11.     orig->get_sequence("WALK FIRE LEFT", walk_fire_left_seq);
  12.     orig->get_sequence("WALK FIRE RIGHT", walk_fire_right_seq);
  13.     orig->get_sequence("WALK FIRE UP", walk_fire_up_seq);
  14.     
  15.     orig->get_sequence("JUMP LEFT", jump_left_seq);
  16.     orig->get_sequence("JUMP RIGHT", jump_right_seq);
  17.     orig->get_sequence("JUMP LEFT RIGHT", jump_left_right_seq);
  18.     orig->get_sequence("JUMP FIRE LEFT", jump_fire_left_seq);
  19.     orig->get_sequence("JUMP FIRE RIGHT", jump_fire_right_seq);
  20.     orig->get_sequence("JUMP FIRE UP LEFT", jump_fire_up_left_seq);
  21.     orig->get_sequence("JUMP FIRE UP RIGHT", jump_fire_up_right_seq);
  22.     
  23.     orig->get_sequence("DUCK LEFT", duck_left_seq);
  24.     orig->get_sequence("DUCK RIGHT", duck_right_seq);
  25.     orig->get_sequence("DUCK LEFT RIGHT", duck_left_right_seq);
  26.     orig->get_sequence("DUCK FIRE LEFT", duck_fire_left_seq);
  27.     orig->get_sequence("DUCK FIRE RIGHT", duck_fire_right_seq);
  28.     
  29.     orig->get_sequence("JET LEFT", jet_left_seq);
  30.     orig->get_sequence("JET RIGHT", jet_right_seq);
  31.     orig->get_sequence("JET LEFT RIGHT", jet_left_right_seq);
  32.     orig->get_sequence("JET FIRE LEFT", jet_fire_left_seq);
  33.     orig->get_sequence("JET FIRE RIGHT", jet_fire_right_seq);
  34.     orig->get_sequence("JET FIRE UP LEFT", jet_fire_up_left_seq);
  35.     orig->get_sequence("JET FIRE UP RIGHT", jet_fire_up_right_seq);
  36.     orig->get_sequence("JET ON LEFT", jet_on_left_seq);
  37.     orig->get_sequence("JET ON RIGHT", jet_on_right_seq);
  38.     orig->get_sequence("JET OFF LEFT", jet_off_left_seq);
  39.     orig->get_sequence("JET OFF RIGHT", jet_off_right_seq);
  40.     
  41.     orig->get_sequence("KICK LEFT", kick_left_seq);
  42.     orig->get_sequence("KICK RIGHT", kick_right_seq);
  43.     
  44.     orig->get_sequence("STUNNED", stunned_seq);
  45.     orig->get_sequence("CAPTURED", captured_seq);
  46.     orig->get_sequence("CLIMBING", climbing_seq);
  47.     
  48.     // Set boundaries
  49.     
  50.     orig->get_circles("STANDING", &bounds_standing);
  51.     orig->get_circles("DUCKED", &bounds_ducked);
  52.     
  53.     // Circles for kick
  54.     
  55.     orig->get_circles("KICK LEFT", &kick_left_circle);
  56.     orig->get_circles("KICK RIGHT", &kick_right_circle);
  57.     
  58.     // Set spots
  59.     
  60.     orig->get_spots("WALK FIRE LEFT", &walk_fire_left_spot);
  61.     orig->get_spots("WALK FIRE RIGHT", &walk_fire_right_spot);
  62.     orig->get_spots("WALK FIRE UP", &walk_fire_up_spot);
  63.     
  64.     orig->get_spots("JUMP FIRE LEFT", &jump_fire_left_spot);
  65.     orig->get_spots("JUMP FIRE RIGHT", &jump_fire_right_spot);
  66.     orig->get_spots("JUMP FIRE UP LEFT", &jump_fire_up_left_spot);
  67.     orig->get_spots("JUMP FIRE UP RIGHT", &jump_fire_up_right_spot);
  68.     
  69.     orig->get_spots("JET FIRE LEFT", &jet_fire_left_spot);
  70.     orig->get_spots("JET FIRE RIGHT", &jet_fire_right_spot);
  71.     orig->get_spots("JET FIRE UP LEFT", &jet_fire_up_left_spot);
  72.     orig->get_spots("JET FIRE UP RIGHT", &jet_fire_up_right_spot);
  73.     
  74.     orig->get_spots("DUCK FIRE LEFT", &duck_fire_left_spot);
  75.     orig->get_spots("DUCK FIRE RIGHT", &duck_fire_right_spot);
  76.     
  77.     orig->get_spots("FIRE DOWN", &fire_down_spot);
  78.     
  79.     // Get sounds
  80.     
  81.     orig->get_soundsequence("GOT HIT", snd_gothit);
  82.     
  83.     // Clear weapons
  84.     
  85.     weapon = 0;
  86.     weapon_down = 0;
  87.     
  88.     // Reset score counters
  89.     
  90.     deaths = 0;
  91.     stuns = 0;
  92.     shots_fired = 0;
  93.     
  94.     // Set text stuff
  95.  
  96.     text_above_char = new cText (&texts);
  97.     text_above_char->set_centered(TRUE);
  98.         
  99.     // Setup other variables
  100.  
  101.     influenced_by_catapult = TRUE;    
  102.     influenced_by_inpenetrable = TRUE;
  103.  
  104.     // Revive character and put it in a bubble
  105.  
  106.     revive();
  107. } 
  108.  
  109. void cCharacter::revive()
  110. {
  111.     // Set some variables
  112.     
  113.     stop_movement();
  114.     
  115.     ay = GRAVITY;
  116.     
  117.     armor = orig->params->get_int("*ARMOR", 100);
  118.     
  119.     ducked = FALSE;
  120.     circle_bounds = bounds_standing;
  121.     
  122.     standing = FALSE;
  123.     climbing = FALSE;
  124.     captured = 0;
  125.     
  126.     dead = FALSE;
  127.     
  128.     jetpack_active = FALSE;
  129.     jetpack_time = JETPACK_TIME;
  130.     
  131.     stunned = 0;
  132.     firing = 0;
  133.     ignore_platforms = 0;
  134.     next_stun_time = 2 * sec;
  135.     invulnerable = CHAR_INVULNERABLE;
  136.     
  137.     last_move = CHAR_LEFT;
  138.     horiz_speed = 0;
  139.     set_last_in_sequence(jump_left_seq);
  140.     
  141.     // Weapon is standard gun
  142.  
  143.     weapon->delete_list();
  144.     new cInventoryBullet(&weapon);
  145.     
  146.     weapon_down->delete_list();
  147. }
  148.  
  149. cCharacter::~cCharacter()
  150. {
  151.     // Delete weapons
  152.     
  153.     weapon->delete_list();
  154.     weapon_down->delete_list();
  155.     
  156.     // Delete boundaries
  157.     
  158.     bounds_standing->delete_list();
  159.     bounds_ducked->delete_list();
  160.     
  161.     // Delete circles
  162.     
  163.     kick_left_circle->delete_list();
  164.     kick_right_circle->delete_list();
  165.     
  166.     // Delete spots
  167.     
  168.     walk_fire_left_spot->delete_list();
  169.     walk_fire_right_spot->delete_list();
  170.     walk_fire_up_spot->delete_list();
  171.     
  172.     jump_fire_left_spot->delete_list();
  173.     jump_fire_right_spot->delete_list();
  174.     jump_fire_up_left_spot->delete_list();
  175.     jump_fire_up_right_spot->delete_list();
  176.     
  177.     duck_fire_left_spot->delete_list();
  178.     duck_fire_right_spot->delete_list();
  179.     
  180.     jet_fire_left_spot->delete_list();
  181.     jet_fire_right_spot->delete_list();
  182.     jet_fire_up_left_spot->delete_list();
  183.     jet_fire_up_right_spot->delete_list();
  184.     
  185.     fire_down_spot->delete_list();
  186.  
  187.     // Delete text
  188.  
  189.     delete text_above_char;
  190. }
  191.  
  192. void cCharacter::set_horiz_speed(int new_speed)
  193. {
  194.     // First substract old speed
  195.     
  196.     vx -= (fix)horiz_speed;
  197.     
  198.     // Add new speed
  199.     
  200.     vx += new_speed;
  201.     
  202.     // Remember new speed
  203.     
  204.     horiz_speed = new_speed;
  205. }
  206.  
  207. void cCharacter::walk_turn_left()
  208. {
  209.     if (last_move != CHAR_LEFT)
  210.         set_inverse_sequence(walk_left_right_seq);
  211.     
  212.     last_move = CHAR_LEFT;
  213. }
  214.  
  215. void cCharacter::walk_left()
  216. {
  217.     walk_turn_left();
  218.     
  219.     set_horiz_speed(-CHAR_WALK_SPEED);
  220. }
  221.  
  222. void cCharacter::walk_turn_right()
  223. {
  224.     if (last_move != CHAR_RIGHT)
  225.         set_sequence(walk_left_right_seq);
  226.     
  227.     last_move = CHAR_RIGHT;
  228. }
  229.  
  230. void cCharacter::walk_right()
  231. {
  232.     walk_turn_right();
  233.     
  234.     set_horiz_speed(CHAR_WALK_SPEED);
  235. }
  236.  
  237. void cCharacter::walk_h_halt()
  238. {
  239.     cAnimation c = get_sequence();
  240.     
  241.     if (c.start_frame == walk_left_seq.start_frame || c.start_frame == walk_right_seq.start_frame)
  242.         stop_animation();
  243.     
  244.     set_horiz_speed(0);
  245. }
  246.  
  247. void cCharacter::climb_turn_left()
  248. {
  249.     last_move = CHAR_LEFT;
  250. }
  251.  
  252. void cCharacter::climb_left()
  253. {
  254.     climb_turn_left();
  255.     
  256.     set_horiz_speed(-CHAR_CLIMB_SPEED);
  257. }
  258.  
  259. void cCharacter::climb_turn_right()
  260. {
  261.     last_move = CHAR_RIGHT;
  262. }
  263.  
  264. void cCharacter::climb_right()
  265. {
  266.     last_move = CHAR_RIGHT;
  267.     
  268.     set_horiz_speed(CHAR_CLIMB_SPEED);
  269. }
  270.  
  271. void cCharacter::climb_up()
  272. {
  273.     vy = CHAR_CLIMB_SPEED;
  274. }
  275.  
  276. void cCharacter::climb_down()
  277. {
  278.     vy = -CHAR_CLIMB_SPEED;
  279. }
  280.  
  281. void cCharacter::climb_h_halt()
  282. {
  283.     set_horiz_speed(0);
  284. }
  285.  
  286. void cCharacter::climb_v_halt()
  287. { 
  288.     vy = 0;
  289. }
  290.  
  291. void cCharacter::jet_on()
  292. {
  293.     if (!jetpack_active && jetpack_time > 0)
  294.     {
  295.         ay = 0;
  296.         vy = 0;
  297.         
  298.         jetpack_active = TRUE;
  299.         jetpack_timer = 0;
  300.         
  301.         set_sequence(last_move == CHAR_LEFT? jet_on_left_seq:jet_on_right_seq);
  302.     }
  303. }
  304.  
  305. void cCharacter::jet_off()
  306. {   
  307.     if (jetpack_active)
  308.     {
  309.         ay = GRAVITY;
  310.         
  311.         jetpack_active = FALSE;
  312.         
  313.         set_sequence(last_move == CHAR_LEFT? jet_off_left_seq:jet_off_right_seq);
  314.     }
  315. }
  316.  
  317. void cCharacter::jet_turn_left()
  318. {
  319.     if (last_move != CHAR_LEFT)
  320.         set_inverse_sequence(jet_left_right_seq);
  321.     
  322.     last_move = CHAR_LEFT;
  323. }
  324.  
  325. void cCharacter::jet_left()
  326. {
  327.     jet_turn_left();
  328.     
  329.     set_horiz_speed(-JETPACK_SPEED);
  330. }
  331.  
  332. void cCharacter::jet_turn_right()
  333. {
  334.     if (last_move != CHAR_RIGHT)
  335.         set_sequence(jet_left_right_seq);
  336.     
  337.     last_move = CHAR_RIGHT;
  338. }
  339.  
  340. void cCharacter::jet_right()
  341. {
  342.     jet_turn_right();
  343.     
  344.     set_horiz_speed(JETPACK_SPEED);
  345. }
  346.  
  347. void cCharacter::jet_up()
  348. {
  349.     vy = JETPACK_SPEED;
  350. }
  351.  
  352. void cCharacter::jet_down()
  353. {
  354.     vy = -JETPACK_SPEED;
  355. }
  356.  
  357. void cCharacter::jet_h_halt()
  358. {
  359.     set_horiz_speed(0);
  360. }
  361.  
  362. void cCharacter::jet_v_halt()
  363. {
  364.     vy = 0;
  365. }
  366.  
  367. void cCharacter::jump()
  368. {
  369.     stand();
  370.     
  371.     vy = CHAR_JUMP_SPEED;
  372.     
  373.     set_sequence(last_move == CHAR_LEFT? jump_left_seq:jump_right_seq);
  374. }
  375.  
  376. void cCharacter::jump_turn_left()
  377. {
  378.     if (last_move != CHAR_LEFT)
  379.         set_inverse_sequence(jump_left_right_seq);
  380.     
  381.     last_move = CHAR_LEFT;
  382. }
  383.  
  384. void cCharacter::jump_left()
  385. {
  386.     jump_turn_left();
  387.     
  388.     set_horiz_speed(-CHAR_WALK_SPEED);
  389. }
  390.  
  391. void cCharacter::jump_turn_right()
  392. {
  393.     if (last_move != CHAR_RIGHT)
  394.         set_sequence(jump_left_right_seq);
  395.     
  396.     last_move = CHAR_RIGHT;
  397. }
  398.  
  399. void cCharacter::jump_right()
  400. {
  401.     jump_turn_right();
  402.     
  403.     set_horiz_speed(CHAR_WALK_SPEED);
  404. }
  405.  
  406. void cCharacter::jump_h_halt()
  407. {
  408.     set_horiz_speed(0);
  409. }
  410.  
  411. void cCharacter::duck()
  412. {
  413.     if (standing && !ducked)
  414.     {
  415.         ducked = TRUE;
  416.         circle_bounds = bounds_ducked;
  417.         
  418.         set_horiz_speed(0);
  419.         
  420.         set_sequence(last_move == CHAR_LEFT? duck_left_seq:duck_right_seq);
  421.     }
  422. }
  423.  
  424. void cCharacter::duck_left()
  425. {
  426.     if (last_move != CHAR_LEFT)
  427.         set_inverse_sequence(duck_left_right_seq);
  428.     
  429.     last_move = CHAR_LEFT;
  430. }
  431.  
  432. void cCharacter::duck_right()
  433. {
  434.     if (last_move != CHAR_RIGHT)
  435.         set_sequence(duck_left_right_seq);
  436.     
  437.     last_move = CHAR_RIGHT;
  438. }
  439.  
  440. void cCharacter::stand()
  441. {
  442.     circle_bounds = bounds_standing;
  443.     
  444.     if (ducked)
  445.     {
  446.         ducked = FALSE;
  447.         
  448.         set_inverse_sequence(last_move == CHAR_LEFT? duck_left_seq:duck_right_seq);
  449.         add_last_in_sequence(last_move == CHAR_LEFT? walk_left_seq:walk_right_seq);
  450.     }
  451. }
  452.  
  453. void cCharacter::fire()
  454. {
  455.     cCharacter *ch;
  456.     cCircle *c;
  457.     
  458.     if (weapon == 0 || firing)
  459.         return;
  460.     
  461.     // Increase shots fired
  462.  
  463.     shots_fired++;
  464.     
  465.     // Check kick distance    
  466.  
  467.     c = last_move == CHAR_LEFT? kick_left_circle:kick_right_circle;
  468.     ch = (cCharacter *)check_radial_boundaries(c, players);    
  469.  
  470.     if (ch != 0 && captured == 0 && ch->captured == 0)
  471.     {
  472.         firing = CHAR_KICK_DLY;
  473.  
  474.         int was_active = ch->is_active();
  475.  
  476.         // Do kick and push
  477.  
  478.         ch->push(angle(c->x, 10), CHAR_KICK_POWER);
  479.         ch->hit(CHAR_KICK_APOWER);
  480.         
  481.         // Create effect and set animation
  482.         
  483.         new cEffect (x + c->x, y - c->y, orig, "KICK EFFECT");
  484.         set_sequence(last_move == CHAR_LEFT? kick_left_seq:kick_right_seq);
  485.  
  486.         // Award points if other character was active
  487.  
  488.         if (was_active)
  489.             modify_score(30 + (ch->is_active()? 0 : 50), ch);
  490.     }
  491.     else
  492.     {
  493.         firing = weapon->fire_delay;        
  494.         
  495.         if (last_move == CHAR_LEFT)
  496.         {
  497.             if (captured != 0)
  498.             {
  499.                 delete captured;
  500.             }
  501.             else if (jetpack_active)
  502.             {
  503.                 set_sequence(jet_fire_left_seq);
  504.                 weapon->fire(jet_fire_left_spot, x, y, 128, this);
  505.             }
  506.             else if (ducked)
  507.             {
  508.                 set_sequence(duck_fire_left_seq);
  509.                 weapon->fire(duck_fire_left_spot, x, y, 128, this);
  510.             }
  511.             else if (standing)
  512.             {
  513.                 set_sequence(walk_fire_left_seq);
  514.                 weapon->fire(walk_fire_left_spot, x, y, 128, this);
  515.             }
  516.             else
  517.             {
  518.                 set_sequence(jump_fire_left_seq);
  519.                 weapon->fire(jump_fire_left_spot, x, y, 128, this);
  520.             }
  521.         }
  522.         else
  523.         {
  524.             if (captured != 0)
  525.             {
  526.                 delete captured;
  527.             }
  528.             else if (jetpack_active)
  529.             {
  530.                 set_sequence(jet_fire_right_seq);
  531.                 weapon->fire(jet_fire_right_spot, x, y, 0, this);
  532.             }
  533.             else if (ducked)
  534.             {
  535.                 set_sequence(duck_fire_right_seq);
  536.                 weapon->fire(duck_fire_right_spot, x, y, 0, this);
  537.             }
  538.             else if (standing)
  539.             {
  540.                 set_sequence(walk_fire_right_seq);
  541.                 weapon->fire(walk_fire_right_spot, x, y, 0, this);
  542.             }
  543.             else
  544.             {
  545.                 set_sequence(jump_fire_right_seq);
  546.                 weapon->fire(jump_fire_right_spot, x, y, 0, this);
  547.             }
  548.         }
  549.     }
  550. }
  551.  
  552. void cCharacter::fire_up()
  553. {
  554.     if (weapon == 0 || firing)
  555.         return;
  556.     
  557.     // Increase shots fired
  558.  
  559.     shots_fired++;
  560.     
  561.     // Make sure we're standing
  562.  
  563.     stand();
  564.  
  565.     // Fire
  566.     
  567.     firing = weapon->fire_delay;
  568.     
  569.     if (captured != 0)
  570.     {
  571.         delete captured;
  572.     }
  573.     else if (jetpack_active)
  574.     {
  575.         set_sequence(last_move == CHAR_LEFT? jet_fire_up_left_seq:jet_fire_up_right_seq);
  576.         weapon->fire(last_move == CHAR_LEFT? jet_fire_up_left_spot:jet_fire_up_right_spot, x, y, 64, this);
  577.     }
  578.     else if (standing)
  579.     {
  580.         set_sequence(walk_fire_up_seq);
  581.         weapon->fire(walk_fire_up_spot, x, y, 64, this);
  582.     }
  583.     else
  584.     {
  585.         set_sequence(last_move == CHAR_LEFT? jump_fire_up_left_seq:jump_fire_up_right_seq);
  586.         weapon->fire(last_move == CHAR_LEFT? jump_fire_up_left_spot:jump_fire_up_right_spot, x, y, 64, this);
  587.     }
  588. }
  589.  
  590. void cCharacter::fire_down()
  591. {
  592.     if (weapon_down == 0 || firing)
  593.         return;
  594.  
  595.     // Increase shots fired
  596.  
  597.     shots_fired++;
  598.         
  599.     // Fire down
  600.  
  601.     firing = weapon_down->fire_delay;
  602.     
  603.     if (captured != 0)
  604.     {
  605.         delete captured;
  606.     }
  607.     else
  608.     {
  609.         weapon_down->fire(fire_down_spot, x, y, -64, this);
  610.     }
  611. }
  612.  
  613. void cCharacter::hit(int armor_power)
  614. {
  615.     // If already dead do nothing
  616.     
  617.     if (dead)
  618.         return;
  619.     
  620.     // Auch!
  621.     
  622.     set_soundsequence(snd_gothit);
  623.     
  624.     // Impossible to hit?
  625.     
  626.     if (stunned || invulnerable || captured != 0)
  627.         return;
  628.     
  629.     // Substract value from armor
  630.     
  631.     armor -= armor_power;
  632.     
  633.     // Put remaining armor above player
  634.     
  635.     if (armor_power > 0)
  636.         set_text_above(construct("%d%%", armor <= 0? 0:armor), sec);
  637.     
  638.     // Stun if no armor left
  639.     
  640.     if (armor <= 0)
  641.     {
  642.         stuns++;
  643.  
  644.         modify_score(-50);
  645.  
  646.         stunned = next_stun_time;
  647.         invulnerable = next_stun_time + CHAR_INVULNERABLE;
  648.         
  649.         make_dirty();
  650.         
  651.         stand();
  652.         jet_off();
  653.         
  654.         set_horiz_speed(0);
  655.         ay = GRAVITY;
  656.         
  657.         set_sequence(stunned_seq);
  658.         
  659.         make_dirty();
  660.         
  661.         next_stun_time += sec / 2;
  662.         
  663.         armor = orig->params->get_int("*ARMOR", 100);
  664.     }
  665. }
  666.  
  667. void cCharacter::push(fix dir, int distance, fix speed, int ignore)
  668. { 
  669.     // Check if dead
  670.     
  671.     if (dead || captured != 0)
  672.         return;  
  673.     
  674.     if (distance != 0)
  675.         new_angular_push((fix)0.5, vpush_tx((fix)0.5, distance), apush_tx((fix)0.5, distance), dir);
  676.     
  677.     if (speed != (fix)0)
  678.         add_angular_speed(speed - get_speed(dir), dir);
  679.     
  680.     if (ignore > 0)
  681.         ignore_platforms = ignore;
  682. }
  683.  
  684. void cCharacter::capture(cBubble *captor)
  685. {
  686.     if (captured == 0)
  687.     {
  688.         captured = captor;
  689.         
  690.         stand();
  691.         jet_off();
  692.         
  693.         stop_movement();
  694.         
  695.         set_sequence(captured_seq);
  696.     }
  697. }
  698.  
  699. void cCharacter::release()
  700. {
  701.     if (captured != 0)
  702.     {
  703.         captured = 0;
  704.         
  705.         ay = GRAVITY;
  706.         
  707.         set_animation();
  708.     }
  709. }
  710.  
  711. void cCharacter::set_text_above(char *text, int time)
  712. {
  713.     text_above_char->make_dirty();
  714.     text_above_char->set_text(text);
  715.     text_above_char->set_position(x, y + CHAR_TEXT_DISTANCE);
  716.     text_above_char->make_dirty();
  717.     
  718.     keep_showing_text = time;
  719. }
  720.  
  721. void cCharacter::kill_text_above()
  722. {
  723.     text_above_char->make_dirty();
  724.     text_above_char->set_text(0);
  725. }
  726.  
  727. void cCharacter::update_text_above()
  728. {
  729.     if (keep_showing_text)
  730.     {
  731.         text_above_char->make_dirty();
  732.         text_above_char->set_position(x, y + CHAR_TEXT_DISTANCE);
  733.         text_above_char->make_dirty();
  734.     }
  735.     else
  736.     {
  737.         kill_text_above();
  738.     }
  739. }
  740.  
  741. void cCharacter::set_animation()
  742. {
  743.     if (stunned)
  744.     {
  745.         set_last_in_sequence(stunned_seq);
  746.     }
  747.     else if (captured != 0)
  748.     {
  749.         set_sequence(captured_seq);
  750.     }
  751.     else if (jetpack_active)
  752.     {
  753.         set_sequence(last_move == CHAR_RIGHT? jet_right_seq:jet_left_seq);
  754.     }
  755.     else if (climbing)
  756.     {
  757.         if (abs(vx) > (fix)1 || vy > (fix)1)
  758.             set_sequence(climbing_seq);
  759.         else if (vy < (fix)-1)
  760.             set_inverse_sequence(climbing_seq);
  761.         else
  762.             set_last_in_sequence(climbing_seq);
  763.     }
  764.     else if (ducked)
  765.     {
  766.         set_last_in_sequence(last_move == CHAR_RIGHT? duck_right_seq:duck_left_seq);
  767.     }
  768.     else if (standing)
  769.     {
  770.         if (abs(vx) > (fix)1)
  771.             set_sequence(last_move == CHAR_RIGHT? walk_right_seq:walk_left_seq);
  772.         else
  773.             set_last_in_sequence(last_move == CHAR_RIGHT? walk_right_seq:walk_left_seq);
  774.     }
  775.     else
  776.         set_last_in_sequence(last_move == CHAR_RIGHT? jump_right_seq:jump_left_seq);
  777. }
  778.  
  779. int cCharacter::control()
  780. {
  781.     cGameObject::control();
  782.     
  783.     // Check if we're dead/dying
  784.     
  785.     if (dead)
  786.     {
  787.         set_image(0);
  788.         set_position(x, surface->start);
  789.         stop_movement();
  790.         kill_text_above();
  791.         
  792.         return dead_timer;
  793.     }
  794.     
  795.     // Check if we're captured by something
  796.     
  797.     if (captured != 0)
  798.     {
  799.         if (animation_done())
  800.             set_sequence(captured_seq);
  801.  
  802.         stop_movement();
  803.         
  804.         update_text_above();
  805.         
  806.         return TRUE;
  807.     }
  808.     
  809.     // Set transparent if invulnerable
  810.     
  811.     set_colormap(invulnerable && !stunned? cmap_gray:0);
  812.     
  813.     // Check inpenetrable walls
  814.     
  815.     check_radial_boundaries(circle_bounds, structures, cStructure::check_inpenetrable);
  816.  
  817.     // Do jetpack stuff
  818.     
  819.     if (jetpack_active)
  820.     {
  821.         jetpack_time -= jetpack_timer.raw_delta();
  822.         
  823.         if (jetpack_time <= 0)
  824.         {
  825.             jetpack_time = 0;
  826.             
  827.             jet_off();
  828.         }
  829.     }
  830.     
  831.     // Check if character is on stairs
  832.     
  833.     int was_climbing = climbing;
  834.     
  835.     climbing = !ignore_platforms && is_active() && !jetpack_active
  836.         && check_radial_boundaries(circle_bounds, stairs) != 0;
  837.     
  838.     if (was_climbing && !climbing && vy == (fix)CHAR_CLIMB_SPEED)
  839.         vy = CHAR_JUMP_SPEED;
  840.     
  841.     if ((was_climbing && !climbing) || (!was_climbing && climbing))
  842.         stop_animation();
  843.     
  844.     // Check if character landed
  845.     
  846.     standing = !ignore_platforms && !jetpack_active && !climbing
  847.                && check_resting_on_boundaries(line_bounds, structures);
  848.     
  849.     if (standing)
  850.         vy = 0;
  851.     else
  852.         stand(); 
  853.     
  854.     // Adjust vertical motion
  855.         
  856.     if (climbing || jetpack_active)
  857.         ay = 0;
  858.     else
  859.         ay = GRAVITY;
  860.  
  861.     // Adjust horizontal motion
  862.  
  863.     ax = 0;
  864.     
  865.     if (!x_on_screen())
  866.         horiz_speed = 0, vx = 0;
  867.     else if (!is_x_pushed())
  868.         vx = horiz_speed;
  869.     
  870.     // Animate
  871.     
  872.     if (animation_done())
  873.         set_animation();
  874.     
  875.     // Set bounds
  876.     
  877.     circle_bounds = !stunned && !ducked? bounds_standing:bounds_ducked;
  878.     
  879.     // Die ?
  880.     
  881.     if (in_water())
  882.     { 
  883.         dead = TRUE;
  884.         dead_timer = 3 * sec;
  885.  
  886.         armor = 0;
  887.         circle_bounds = 0;
  888.         
  889.         deaths++;
  890.  
  891.         modify_score(-200);
  892.     }
  893.     
  894.     update_text_above();
  895.     
  896.     return TRUE;
  897. }
  898.